package thread;
class SingletonLazy {
    private static volatile SingletonLazy instance = null;


    //不安全
//    public static SingletonLazy getInstance(){
//        if(instance == null){
//            return new SingletonLazy();
//        }
//        return instance;
//    }

    //这两个if很有用
    //两个if执行时机可能会差异很大，结果也可能截然相反
    //一旦进入加锁环节，会产生阻塞，这个阻塞时间可能很久，进一步导致阻塞过程中。instance会发生改变（其他线程把instance更改）
//    static SingletonLazy getInstance(){
//        if (instance == null){
//            synchronized (SingletonLazy.class) {
//                if (instance == null) {
//                    return new SingletonLazy();
//                }
//            }
//        }
//        return instance;
//    }
    //代码这样写，后续每次调用getInstance 都需要先加锁
    //事实上，懒汉模式的线程安全问题，只是出现在最开始是时候
    //一旦对象new出来之后，后续多线程调用getInstance就只有读操作，不会不安全了
    //但是new操作会触发指令重排序，会使instance先变为非空，但是并没有初始化
    //如果此时t2线程去调用，会导致问题
    //解决的办法是，用volatile解决

    static SingletonLazy getInstance(){
        if (instance == null){
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    return new SingletonLazy();
                }
            }
        }
        return instance;
    }
    private SingletonLazy(){}
}
public class demo24 {

    public static void main(String[] args) {
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }



}
